rochars / byte-data

 * from-bytes: convert bytes to numbers and strings.

 * Copyright (c) 2017 Rafael da Silva Rocha.

 * https://github.com/rochars/byte-data

 */

const reader = require("../src/read-bytes.js");

const bitDepths = require("../src/bit-depth.js");

const helpers = require("../src/helpers.js");

/**

 * Turn a byte buffer into what the bytes represent.

 * @param {!Array<number>|Uint8Array} buffer An array of bytes.

 * @param {number} bitDepth The bit depth of the data.

 *   Possible values are 1, 2, 4, 8, 16, 24, 32, 40, 48 or 64.

 * @param {Object} options The options. They are:

 *   - "signed": If the numbers are signed. Default is false (unsigned).

 *   - "float": True for floating point numbers. Default is false.

 *       This option is available for 16, 32 and 64-bit numbers.

 *   - "base": The base of the input. Default is 10. Can be 2, 10 or 16.

 *   - "char": If the bytes represent a string. Default is false.

 *   - "be": If the values are big endian. Default is false (little endian).

 *   - "single": If it should return a single value instead of an array.

 *       Default is false.

 * @return {!Array<number>|string}

 */

function fromBytes(buffer, bitDepth, options={"base": 10}) {

    helpers.makeBigEndian(buffer, options.be, bitDepth);

    helpers.bytesToInt(buffer, options.base);

    let values = readBytes(

            buffer,

            bitDepth,

            options.signed,

            getBitReader(bitDepth, options.float, options.char)

        );

    if (options.char) {

        values = values.join("");

    }

    if (options.single) {

        values = values[0];

    }

    return values;

}

/**

 * Turn a array of bytes into an array of what the bytes should represent.

 * @param {!Array<number>|Uint8Array} bytes An array of bytes.

 * @param {number} bitDepth The bitDepth. 1, 2, 4, 8, 16, 24, 32, 40, 48, 64.

 * @param {boolean} isSigned True if the values should be signed.

 * @param {Function} bitReader The function to read the bytes.

 * @return {!Array<number>|string}

 */

function readBytes(bytes, bitDepth, isSigned, bitReader) {

    let values = [];

    let i = 0;

    let j = 0;

    let offset = bitDepths.BitDepthOffsets[bitDepth];

    let len = bytes.length - (offset -1);

    let maxBitDepthValue = bitDepths.BitDepthMaxValues[bitDepth];

    while (i < len) {

        values[j] = signFunction(bitReader(bytes, i), maxBitDepthValue);

        i += offset;

        j++;

    }

    return values;

}

/**

 * Return a function to read binary data.

 * @param {number} bitDepth The bitDepth. 1, 2, 4, 8, 16, 24, 32, 40, 48, 64.

 * @param {boolean} isFloat True if the values are IEEE floating point numbers.

 * @param {boolean} isChar True if it is a string.

 * @return {Function}

 */

function getBitReader(bitDepth, isFloat, isChar) {

    let bitReader;

    if (isChar) {

        bitReader = reader.readChar;

    } else {

        bitReader = reader[getReaderFunctionName(bitDepth, isFloat)];

    }

    return bitReader;

}

/**

 * Build a bit reading function name based on the arguments.

 * @param {number} bitDepth The bitDepth. 1, 2, 4, 8, 16, 24, 32, 40, 48, 64.

 * @param {boolean} isFloat True if the values are IEEE floating point numbers.

 * @return {string}

 */

function getReaderFunctionName(bitDepth, isFloat) {

    return 'read' +

        ((bitDepth == 2 || bitDepth == 4) ? 8 : bitDepth) +

        'Bit' +

        (isFloat ? "Float" : "");

}

module.exports.fromBytes = fromBytes;